/**
 * 
 */
package edu.uoc.tds.pec4.server.impl;

import java.io.Serializable;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Date;


import edu.uoc.tds.pec4.beans.Asistencia;
import edu.uoc.tds.pec4.beans.Aula;
import edu.uoc.tds.pec4.beans.Curso;
import edu.uoc.tds.pec4.beans.ConvocatoriaCurso;
import edu.uoc.tds.pec4.beans.EstadoMatricula;
import edu.uoc.tds.pec4.beans.Grupo;
import edu.uoc.tds.pec4.beans.Matricula;
import edu.uoc.tds.pec4.beans.InformeMatricula;
import edu.uoc.tds.pec4.beans.Usuario;
import edu.uoc.tds.pec4.beans.Recuento;
import edu.uoc.tds.pec4.common.GestionAcademicaInterface;
import edu.uoc.tds.pec4.i18n.TDSLanguageUtils;
import edu.uoc.tds.pec4.server.bbdd.GestorAulas;
import edu.uoc.tds.pec4.server.bbdd.GestorBD;
import edu.uoc.tds.pec4.server.bbdd.GestorCursos;
import edu.uoc.tds.pec4.server.bbdd.GestorConvocatorias;
import edu.uoc.tds.pec4.server.bbdd.GestorGrupos;
import edu.uoc.tds.pec4.server.bbdd.GestorUsuarios;
import edu.uoc.tds.pec4.server.bbdd.GestorMatriculas;
import edu.uoc.tds.pec4.server.bbdd.GestorAsistencias;


/**
 * @author pacomu
 *
 */
public class GestionAcademicaInterfaceImpl extends UnicastRemoteObject implements GestionAcademicaInterface , Serializable  {

	/**
	 * 
	 */
	
	private static final long serialVersionUID = 1L;
	private Connection conexion;
	private List<Recuento> lRecuentos;

	/**
	 * 
	 */

	GestorBD gestorBD = null;
	
	
	public GestionAcademicaInterfaceImpl() throws RemoteException {
		super();

		try {
			gestorBD = new GestorBD();
			gestorBD.iniciarConexion();
			conexion = gestorBD.getConexion();
		}catch (SQLException sqle) {
			throw new RemoteException((TDSLanguageUtils.getMessage("mensaje.remoto.conexionFallida"))+ sqle.getMessage());
		} catch (Exception e) {
			throw new RemoteException((TDSLanguageUtils.getMessage("mensaje.remoto.general"))+ e.getMessage());
		}	
		lRecuentos=new ArrayList<Recuento>();
	}

		
	    /**
	     * Consulta de Aula por id
	     * @param id Aula
	     * @return objeto Aula
	     */
	    public Aula getAula(int idAula) throws SQLException, Exception {
	    	/*
	        Aula aula = GestorGrupos.obtieneAula(idAula, conexion);
	        return aula;
	        */
			return GestorAulas.getAula(idAula, conexion);
	    }
	    
	    /**
	     * Consulta de Curso por id
	     * @param idCurso
	     * @return objeto Curso
	     */
	    public Curso getCurso(int idCurso) throws SQLException, Exception {
	    	/*
	    	Curso curso = GestorGrupos.obtieneCurso(idCurso, conexion);
			return curso;
			*/
			return GestorCursos.getCurso(idCurso, conexion);
	    }    
		
	    /**
	     * Consulta la Convocatoria del Curso por idCurso
	     * @param idCurso
	     * @return objeto ConvocatoriaCurso
	     */
	    public ConvocatoriaCurso getConvocatoria(int idCurso) throws SQLException, Exception {

	    	return GestorConvocatorias.getConvocatoria(idCurso, conexion);
	    }  
		/** 
		* Método para obtener una lista de convocatorias de cursos
		* @param condicion para incluir en el where 
		* @return Lista de convocatorias de cursos
		* @throws RemoteException
		*/
		public List<ConvocatoriaCurso> listaConvocatorias(String condicion) throws RemoteException, SQLException, Exception {
			
			return GestorConvocatorias.listaConvocatorias(condicion, conexion);
		}
		/**
		 * Obtiene una lista de los aulas que hay actualmente
		 * 
		 * @return lista de aulas.
		 */
		public List<Aula> listaAulas(String condicion) throws SQLException, Exception {

			return GestorAulas.listaAulas(condicion, conexion);
		}
		
		/**
		 * Obtiene una lista de los grupos que hay actualmente
		 * 
		 * @return lista de Grupo.
		 */
		public List<Grupo> listaGrupos(int campo, String condicion) throws SQLException, Exception {
			List<Grupo> lGrupos = new ArrayList<Grupo>();
			lGrupos = GestorGrupos.listarGrupos(campo, condicion, conexion);
			return lGrupos;
		}
		
		/**
		 * Obtiene una lista de Cursos que hay actualmente
		 * 
		 * @return lista de Curso.
		 */
		public List<Curso> listaCursos(String condicion) throws SQLException, Exception {

			return GestorCursos.listaCursos(condicion, conexion);
		}
		

		/**
		 * Da de alta un grupo
		 * 
		 * @return 1 = alta correcta, 0 = incorrecta.
		 */

		public int altaGrupo(Grupo grupo) throws SQLException, Exception {
			int rdo = 0;
	        rdo = GestorGrupos.insertarGrupo(grupo, conexion);
			return rdo;
		}

		public int modificarGrupo(Grupo grupo) throws RemoteException, SQLException, Exception {
			int rdo = 0;
	        rdo = GestorGrupos.modificarGrupo(grupo, conexion);
			return rdo;
		}


		public Grupo getGrupo(int idGrupo) throws RemoteException,
				SQLException, Exception {
			Grupo grupo = GestorGrupos.obtieneGrupo(idGrupo, conexion);
			return grupo;
		}


		/**
		* Método para leer un usuario 
		* @param idUsuario
		* @return Usuario
		* @throws RemoteException
		*/
		public Usuario getUsuario(int idUsuario) throws RemoteException,
				SQLException, Exception {
			
			return GestorUsuarios.getUsuario(idUsuario, conexion);
		}
	
		/**
		* Método para leer un usuario por login
		* @param login
		* @return Usuario
		* @throws RemoteException
		*/
		public Usuario getUsuarioPorLogin(String login) throws RemoteException, SQLException, Exception {
			
			return GestorUsuarios.getUsuarioPorLogin(login, conexion);
		}	
		/**
		* Método para leer un usuario por huella
		* @param huella
		* @return Usuario
		* @throws RemoteException
		*/
		public Usuario getUsuarioPorHuella(String huella) throws RemoteException, SQLException, Exception {
			
			return GestorUsuarios.getUsuarioPorHuella(huella, conexion);
		}	
		/**
		* Método para leer una matricula 
		* @param idMatricula
		* @return Matricula
		* @throws RemoteException
		*/
		public Matricula getMatricula(int idMatricula) throws RemoteException, SQLException, Exception {
			
			return GestorMatriculas.getMatricula(idMatricula, conexion);
		}


		/**
		* Método para cambiar el estado de una matricula 
		* @param idMatricula , EstadoMatricula
		* @return 1=modificado , 0=no modificado
		* @throws RemoteException
		*/
		public int cambiarEstadoMatricula(int idMatricula, EstadoMatricula estado)
				throws RemoteException, SQLException, Exception {
			
			return GestorMatriculas.cambiarEstadoMatricula(idMatricula, estado, conexion);
		}


		/**
		* Método para cambiar el grupo a una matricula 
		* @param idMatricula, idGrupo
		* @return 1=modificado , 0=no modificado
		* @throws RemoteException
		*/
		public int cambiarGrupoMatricula(int idMatricula, int idGrupo)
				throws RemoteException, SQLException, Exception {
			
			return GestorMatriculas.cambiarGrupoMatricula(idMatricula, idGrupo, conexion);
		}


       /*
       * METODO PARA CONTAR LAS MATRICULAS DE UN GRUPO
       * @param int idGrupo
       * @return cuentaMatriculas
       */
		public int cuentaMatriculasGrupo(int idGrupo) throws RemoteException, SQLException, Exception {

			return GestorMatriculas.contarMatriculasActivasGrupo(idGrupo, conexion);
		}
		
		/**
		* Método para insertar una asistencia 
		* @param Asistencia
		* @return 0=insertada ok, -1=error al insertar
		* @throws RemoteException
		*/
		public int altaAsistencia(Asistencia asistencia) throws RemoteException, SQLException, Exception {
			
			return GestorAsistencias.insertarAsistencia(asistencia, conexion);
		}

		/**
		* Método para leer una asistencia 
		* @param idMatricula, fecha
		* @return Asistencia
		* @throws RemoteException
		*/
		public Asistencia getAsistencia(int idMatricula, Date fecha) throws RemoteException, SQLException, Exception {
			
			return GestorAsistencias.getAsistencia(idMatricula, fecha, conexion);
		}


		/** 
		* Método para obtener una lista de asistencias
		* @param condicion para incluir en el where 
		* @return Lista de asistencias
		* @throws RemoteException
		*/
		public List<Asistencia> listaAsistencias(String condicion) throws RemoteException, SQLException, Exception {
			
			return GestorAsistencias.listaAsistencias(condicion, conexion);
		}

		/**
		* Método para verificar password de un usuario 
		* @param login , password 
		* @return 0=correcto ok, -1=error password incorrecto
		* @throws RemoteException
		*/
		public int conexionUsuario(String login, String password)
				throws RemoteException, SQLException, Exception {
			
	        return GestorUsuarios.conexionUsuario(login, password, conexion);
		}


		public List<Usuario> listaUsuarios(String condicion)   throws SQLException, Exception {

			return GestorUsuarios.listaUsuarios(condicion, conexion);
		}
	

		/** 
		* Método para obtener una lista de matriculas
		* @param condicion para incluir en el where 
		* @return Lista de matriculas
		* @throws RemoteException
		*/
		public List<Matricula> listaMatriculas(String condicion)
				throws RemoteException, SQLException, Exception {
			
			return GestorMatriculas.listaMatriculas(condicion, conexion);
		}
		/** 
		* Método para obtener una lista de matriculas con los datos de usuario, grupo, curso
		* @param condicion para incluir en el where 
		* @return Lista de matriculas con datos detallados
		*/
		public List<InformeMatricula> listaInformeMatriculas(String condicion)
		throws RemoteException, SQLException, Exception {
	
			return GestorMatriculas.listaInfomeMatriculas(condicion, conexion);
		}

		/**
		* M�todo para insertar una matricula 
		* @param Matricula, conexion
		* @return 1=insertado , 0=no insertado
		*/
		public int insertarMatricula(Matricula matricula)throws RemoteException, SQLException, Exception{
			return GestorMatriculas.insertarMatricula(matricula, conexion);
		}
		
		/**
		* Método para activar recuento 
		* @param idProfesor, idGrupo
		* @return 1=inciado , 0=no iniciado
		*/
		public int iniciarRecuento(int idProfesor, int idGrupo) throws RemoteException, Exception{
			int iniciado = 0;
			Recuento recuento = new Recuento(idProfesor,idGrupo);
			if (estaRecuento(recuento)<0){
				recuento.setIniciado(true);
				lRecuentos.add(recuento);
				iniciado=1;
			}		
			return iniciado;
		}
		/**
		* Método para finalizar recuento 
		* @param idProfesor, idGrupo
		* @return 1=finalizado , 0=no finalizado
		*/
		public int finalizarRecuento(int idProfesor, int idGrupo) throws RemoteException, Exception{
			int finalizado = 0;
			Recuento recuento = new Recuento(idProfesor,idGrupo);
			int posicion=estaRecuento(recuento);
			if (posicion>=0){
				lRecuentos.remove(posicion);
				finalizado=1;
			}		
			return finalizado;
		}	
		/**
		* Método para encontrar la posicion lista recuentos
		* @param recuento
		* @return posicion
		*/
		public int estaRecuento(Recuento recuento) throws RemoteException, Exception{
			int posicion = -1;
			for (int i=0;i<lRecuentos.size();i++){
				if (lRecuentos.get(i).getIdProfesor()==recuento.getIdProfesor() && lRecuentos.get(i).getIdGrupo()==recuento.getIdGrupo())
					posicion=i;
			}
			return posicion;
		}
		/** 
		* Método para obtener la lista de recuentos
		* @return Lista de recuentos
		*/
		public List<Recuento> listaRecuentos() throws RemoteException, Exception{
			return lRecuentos;
		}
		/** 
		* Método para borrar la lista de recuentos
		* @return lista vacia
		*/
		public int borraListaRecuentos() throws RemoteException, Exception{
			lRecuentos.clear();
			return lRecuentos.size();
		}
		/** 
		* Método para obtener el numero de recuentos
		* @return numero de recuentos activos
		*/
		public int numeroRecuentos() throws RemoteException, Exception{
			return lRecuentos.size();
		}	
		/** 
		* Método para obtener numero asistencias en un recuento
		* @param idProfesor, idGrupo, fecha, conexion 
		* @return numero de asistencias
		*/
		public int cuentaAsistencias(int idProfesor, int idGrupo, Date fecha) throws RemoteException, SQLException, Exception {

			return GestorAsistencias.cuentaAsistencias(idProfesor, idGrupo, fecha, conexion);
		}	

	}

